package mapper;


import javax.sql.*;
import java.util.*;
import java.sql.SQLException;
import java.io.Serializable;
import java.lang.reflect.*;
import java.beans.*;

/**
 * Created with IntelliJ IDEA.
 * User: Jordi
 * Date: 28/12/12
 * Time: 9:28
 * To change this template use File | Settings | File Templates.
 */
public class MapejadorObjectes {
    protected boolean[] autoIncrement= null;
    protected boolean[] difMajMin = null;
    protected boolean[] moneda = null;
    protected boolean[] finalmenteGrabable = null;
    protected boolean[] solsLectura = null;
    protected boolean[] localitzable = null;
    protected boolean[] signat = null;
    protected boolean[] grabable = null;
    protected int[] midaColumna = null;
    protected int[] tipusColumna = null;
    protected int[] tipusNull = null;
    protected int[] precisio = null;
    protected int[] escala = null;
    protected String[] nomCataleg = null;
    protected String[] nomEsquema = null;
    protected String[] nomTaula = null;
    protected String[] columnaNomClass = null;
    protected String[] etiquetaColumna = null;
    protected String[] nomColumna = null;
    protected String[] columnaNomTipus = null;
    protected String[] columnaNomComplert = null;
    protected String[] nomCamp = null;
    /**
     * reflect.Method no es serializable, por lo que despues de enviar
     * este objeto a otra maquina virtual Java (JavaVM) gravarMethod y
     * llegirMethod serán de tipo null
     */
    protected transient Method[] llegirMethod = null;
    protected transient Method[] gravarMethod = null;
    protected String[] campNomClass = null;
    protected Class[] campClass = null;
    protected int comptadorColumna = 0;
    protected Class peticio = null; // ObjetoPersistente
    protected Map taulesMap = new HashMap();
    // Lanza o no una Excepcion considerando si ObjetoPersistente tiene menos campos que mapeos
    protected boolean throwExcepcioCampInexistent = false;
    /**
     * Almacena y habilita información sobre campos, tablas, columnas, etc.
     *
     */
    public MapejadorObjectes() {
    }
    /** Lee el nombre de catálogo de la tabla de la columna designada.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return nombre del catálogo para la tabla en la que la columna
     * en particular aparece o "" si no es aplicable
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public String getNomCataleg(int columnaIdx) throws SQLException {
        return this.nomCataleg[columnaIdx - 1];
    }
    /**
     * <p>Devuelve el nombre completo calificado de la clase Java cuyas instancias
     * han sido generadas si el método <code>ResultSet.getObject</code>
     * se le llama para recuperar un valor de la columna.
     * <code>ResultSet.getObject</code> puede devolver una subclase de la clase
     * devuelta por este método.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return el nombre calificado completo de la clase en el lenguaje Java
     * que debe ser usada por este método
     * <code>ResultSet.getObject</code> para recuperar el valor en la columna
     * especificada. Este es el nombre d ela clase para el mapeo directo.
     * @exception SQLException si sucede un error de acceso a BBDD
     * @since 1.2
     *
     */
    public String getColumnaNomClass(int columnaIdx) throws SQLException {
        return this.columnaNomClass[columnaIdx - 1];
    }
    /** Devuelve el numero de columnas en este objeto <code>ResultSet</code>.
     *
     * @return numero de columnas
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public int getContadorColumna() throws SQLException {
        return this.comptadorColumna;
    }
    /** Indica el ancho máximo nommal (en caracteres) para la columna designada.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return el número maximo normal permitido de caracteres como ancho
     * de la columna designada
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public int getMidaColumna(int columnaIdx) throws SQLException {
        return this.midaColumna[columnaIdx - 1];
    }
    /** Lee el título indicado de la columna designada para su uso en
     * impresiones y visualizaciones.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return título de columna indicado
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public String getEtiquetaColumna(int columnaIdx) throws SQLException {
        return this.etiquetaColumna[columnaIdx - 1];
    }
    /** Lee el nombre la columna seleccionada.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return nombre columna
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public String getNomColumna(int columnaIdx) throws SQLException {
        return this.nomColumna[columnaIdx - 1];
    }
    /** Recupera el tipo de SQL de la columna designada.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return tipo SQL en formato de java.sql.Types
     * @exception SQLException si sucede un error de acceso a BBDD
     * @see java.sql.Types
     *
     */
    public int getTipusColumna(int columnaIdx) throws SQLException {
        return this.tipusColumna[columnaIdx - 1];
    }
    /** Recupera el tipo de nombre específico de la BBDd para
     * la columna seleccionada.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return nombre de tipo usado por la BBDD. Si el tipo de columna es
     * un tipo definido por el usuario, entonces se devuelve un nombre de tipo
     * completamente calificado.
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public String getColumnaNomTipus(int columnaIdx) throws SQLException {
        return this.columnaNomTipus[columnaIdx - 1];
    }
    /** Devuelve el número de digitos decimales de la columna indicada.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return precision
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public int getPrecisio(int columnaIdx) throws SQLException {
        return this.precisio[columnaIdx - 1];
    }
    /** Devuelve el número de digitos a la derecha del punto decimal
     * en la columna indicada.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return escala
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public int getEscala(int columnaIdx) throws SQLException {
        return this.escala[columnaIdx - 1];
    }
    /** Devuelve el esquema de la tabla de la columna designada.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return nombre del esquema o "" si no es posible
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public String getNomEsquema(int columnaIdx) throws SQLException {
        return this.nomEsquema[columnaIdx - 1];
    }
    /** Devuelve el nombre de tabla de la columna designada.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return nombre de la tabla o "" si no es posible
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public String getNomTaula(int columnaIdx) throws SQLException {
        return this.nomTaula[columnaIdx - 1];
    }
    /** Indica si la columna designada se autonumera automáticamente, siendo
     * de solo lectura
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return <code>true</code> si lo es; <code>false</code> de otra forma
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public boolean isAutoIncremento(int columnaIdx) throws SQLException {
        return this.autoIncrement[columnaIdx - 1];
    }
    /** Indica si distingue entre Mayúsculas y minúsculas
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return <code>true</code> si lo es; <code>false</code> de otra forma
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public boolean isDifMajMin(int columnaIdx) throws SQLException {
        return this.difMajMin[columnaIdx - 1];
    }
    /** Indica si la columna es de un valor monetario.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return <code>true</code> si lo es; <code>false</code> de otra forma
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public boolean isMoneda(int columnaIdx) throws SQLException {
        return this.moneda[columnaIdx - 1];
    }
    /** Indica que la escritura en dicha columna es definitiva.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return <code>true</code> si lo es; <code>false</code> de otra forma
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public boolean isFinalmenteGrabable(int columnaIdx) throws SQLException {
        return this.finalmenteGrabable[columnaIdx - 1];
    }
    /** Indica que los valores de la columna son anulables (null).
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return el estado de anulabilidad de la columna;
     * uno de los siguientes: <code>columnNoNulls</code>,
     * <code>columnNullable</code> o <code>columnNullableUnknown</code>
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public int isTipusNull(int columnaIdx) throws SQLException {
        return this.tipusNull[columnaIdx - 1];
    }
    /** Indica que la columna designada no será grabada.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return <code>true</code> si lo es; <code>false</code> de otra forma
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public boolean isSolsLectura(int columnaIdx) throws SQLException {
        return this.solsLectura[columnaIdx - 1];
    }
    /** indica que la columna puede ser usada en una cláusula WHERE
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return <code>true</code> si lo es; <code>false</code> de otra forma
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public boolean isLocalitzable(int columnaIdx) throws SQLException {
        return this.localitzable[columnaIdx - 1];
    }
    /** Indica si los valores en la columna designada son los números firmados.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return <code>true</code> si lo es; <code>false</code> de otra forma
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public boolean isSignat(int columnaIdx) throws SQLException {
        return this.signat[columnaIdx - 1];
    }
    /** Indica si es posible que una escritura sobre la columna designada dé resultado.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @return <code>true</code> si lo es; <code>false</code> de otra forma
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public boolean isGrabable(int columnaIdx) throws SQLException {
        return this.grabable[columnaIdx - 1];
    }
    /**
     * Asigna si la columna designada será automáticamente numerada,
     * y de solo lectura. Por defecto las columnas de un objeto <code>RowSet</code>
     * no son automáticamente numeradas.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @param propiedad <code>true</code> si la columna se autonumera
     * <code>false</code> en otro caso
     *
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public void setAutoIncrement(int columnaIdx, boolean propiedad) throws SQLException {
        this.autoIncrement[columnaIdx - 1] = propiedad;
    }
    /** Asigna la columna para distinguir mayúsculas de minúsculas.
     * Por defecto es <code>false</code>.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @param propiedad <code>true</code> si la columna las distingue;
     * <code>false</code> en otro caso
     *
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public void setDifMajMin(int columnaIdx, boolean propiedad) throws SQLException {
        this.difMajMin[columnaIdx - 1] = propiedad;
    }
    /** Asigna, si existe, el nombre de catálogo a la columna designada, en el
     * <code>String</code>.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @param nomCataleg el nom del catàleg
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public void setNomCataleg(int columnaIdx, String nomCataleg) throws SQLException {
        this.nomCataleg[columnaIdx - 1] = nomCataleg;
    }
    /** Asigna el numero de columnas en el objeto <code>RowSet</code> en el
     * valor númerico.
     *
     * @param comptadorColumna the number of columns in the <code>RowSet</code> object
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public void setContadorColumna(int comptadorColumna) throws SQLException {
        this.comptadorColumna = comptadorColumna;
    }
    /** Asigna el ancho máximo normal de la columna (en caracteres) en el
     * valor <code>int</code>.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @param longitud en caracteres máxima de ancho de columna
     *
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public void setMidaColumna(int columnaIdx, int longitud) throws SQLException {
        this.midaColumna[columnaIdx - 1] = longitud;
    }
    /** Asigna el titulo de columna indicado, si lo hay, para usarlo en impresiones
     * o en visualizaciones en el <code>String</code>
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @param etiqueta con el titulo de la columna
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public void setEtiquetaColumna(int columnaIdx, String etiqueta) throws SQLException {
        this.etiquetaColumna[columnaIdx - 1] = etiqueta;
    }
    /** Asigna el nombre de la colunmna designada al indicado <code>String</code>.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @param nomColumna el nombre de columna designado
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public void setNomColumna(int columnaIdx, String nomColumna) throws SQLException {
        this.nomColumna[columnaIdx - 1] = nomColumna;
    }
    /** Asigna el tipo SQL de la columna de uno de los indicados.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @param tipoSQL el tipo SQL de la columna
     * @exception SQLException si sucede un error de acceso a BBDD
     * @see java.sql.Types
     *
     */
    public void setTipusColumna(int columnaIdx, int tipoSQL) throws SQLException {
        this.tipusColumna[columnaIdx - 1] = tipoSQL;
    }
    /** Asigna el nombre de tipo de la columna designada que es especifico
     * del origen de datos, si lo hay, al <code>String</code>.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @param nomTipus nombre de tipo especifico de la fuente de datos.
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public void setColumnaNomTipus(int columnaIdx, String nomTipus) throws SQLException {
        this.columnaNomTipus[columnaIdx - 1] = nomTipus;
    }
    /** Asigna la columna como para valores monetarios.
     * Por defecto es <code>false</code>.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @param propiedad <code>true</code> si la columna contiene un valor monetario;
     * <code>false</code> en otro caso
     *
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public void setMoneda(int columnaIdx, boolean propiedad) throws SQLException {
        this.moneda[columnaIdx - 1] = propiedad;
    }
    /** Asigna que la columna indicada puede ser puesta con el valor
     * <code>NULL</code>.
     * Por defecto es <code>ResultSetMetaData.columnNullableUnknown</code>
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @param propiedad una de las constantes siguientes:
     * <code>ResultSetMetaData.columnNoNulls</code>,
     * <code>ResultSetMetaData.columnNullable</code>, o
     * <code>ResultSetMetaData.columnNullableUnknown</code>
     *
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public void setTipusNull(int columnaIdx, int propiedad) throws SQLException {
        this.tipusNull[columnaIdx - 1] = propiedad;
    }
    /** Asigna el número de digitos decimales de la columna en el valor
     * indicado <code>int</code>.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @param precisio el numero total de digitos decimales
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public void setPrecisio(int columnaIdx, int precisio) throws SQLException {
        this.precisio[columnaIdx - 1] = precisio;
    }
    /** Asigna el número de digitos a la derecha del punto decimal para la
     * columna indicada en el valor <code>int</code>.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @param escala numeor de digitos a la derecha del punto decimal
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public void setEscala(int columnaIdx, int escala) throws SQLException {
        this.escala[columnaIdx - 1] = escala;
    }
    /** Asigna el nombre del esquema de la tabla de la columna designada, si lo hay,
     * en el indicado <code>String</code>.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @param nomEsquema nombre de esquema
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public void setNomEsquema(int columnaIdx, String nomEsquema) throws SQLException {
        this.nomEsquema[columnaIdx - 1] = nomEsquema;
    }
    /** Asigna a la columna para poder usarse en las clausulas WHEREe.
     * Por defecto es <code>false</code>.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @param propiedad <code>true</code> si la columna puede usarse en una
     * clausula <code>WHERE</code>; <code>false</code> en otro caso
     *
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public void setLocalitzable(int columnaIdx, boolean propiedad) throws SQLException {
        this.localitzable[columnaIdx - 1] = propiedad;
    }
    /** Asigna a la columna como contenedora de numeros firmados (signed).
     * Por defecto es <code>false</code>.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @param propiedad <code>true</code> si la columna contiene un numero 'signed';
     * <code>false</code> en otro caso
     *
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public void setSignat(int columnaIdx, boolean propiedad) throws SQLException {
        this.signat[columnaIdx - 1] = propiedad;
    }
    /** Asigna el nombre de tabla de la columna, si lo hay, en el valor
     * <code>String</code>.
     *
     * @param columnaIdx la primera columna es 1, la segunda 2, ...
     * @param nomTaula nombre de tabla de la columna
     * @exception SQLException si sucede un error de acceso a BBDD
     *
     */
    public void setNomTaula(int columnaIdx, String nomTaula) throws SQLException {
        this.nomTaula[columnaIdx - 1] = nomTaula;
    }
    public void setGrabable(int columnaIdx, boolean grabable) {
        this.grabable[columnaIdx - 1] = grabable;
        this.solsLectura[columnaIdx - 1] = !grabable;
    }
    public void setFinalmenteGrabable(int columnIndex, boolean finalmenteGrabable) {
        this.finalmenteGrabable[columnIndex - 1] = finalmenteGrabable;
    }
    public void setColumnaNomClass(int columnaIdx, String columnaNomClass) {
        this.columnaNomClass[columnaIdx - 1] = columnaNomClass;
    }
    public void setSolsLectura(int columnaIdx, boolean solsLectura) throws SQLException {
        this.solsLectura[columnaIdx - 1] = solsLectura;
        this.grabable[columnaIdx - 1] = !solsLectura;
    }
    public Map getTablasMap() {
        return taulesMap;
    }
    public void setTablasMap(Map taulesMap) {
        this.taulesMap = taulesMap;
    }
    public String getColumnaNomComplert(int columnaIdx) throws SQLException {
        return this.columnaNomComplert[columnaIdx - 1];
    }
    public void setColumnaNomComplert(int columnaIdx, String nomComplertColumna) throws SQLException {
        this.columnaNomComplert[columnaIdx - 1] = nomComplertColumna;
    }
    public String getNomCamp(int columnIndex) throws SQLException {
        return this.nomCamp[columnIndex - 1];
    }
    public void setNomCamp(int columnaIdx, String nomCamp) throws SQLException {
        this.nomCamp[columnaIdx - 1] = nomCamp;
    }
    public Method getGrabarMethod(int columnaIdx) throws SQLException {
        if (this.gravarMethod == null || this.gravarMethod[columnaIdx - 1] == null) {
            llenarGrabarMethod(columnaIdx, nomCamp[columnaIdx - 1]);
        }
        return this.gravarMethod[columnaIdx - 1];
    }
    public void setGrabarMethod(int columnaIdx, Method gravarMethod) {
        if (this.gravarMethod == null) {
            this.gravarMethod = new Method[comptadorColumna];
        }
        this.gravarMethod[columnaIdx - 1] = gravarMethod;
    }
    public Method getLeerMethod(int columnaIdx) throws SQLException {
        if (this.llegirMethod == null || this.llegirMethod[columnaIdx - 1] == null) {
            llenarLeerMethod(columnaIdx, nomCamp[columnaIdx - 1]);
        }
        return this.llegirMethod[columnaIdx - 1];
    }
    public void setLeerMethod(int columnaIdx, Method llegirMethod) {
        if (this.llegirMethod == null) {
            this.llegirMethod = new Method[comptadorColumna];
        }
        this.llegirMethod[columnaIdx - 1] = llegirMethod;
    }
    public String getCampoNombreClass(int columnaIdx) throws SQLException {
        return this.campNomClass[columnaIdx - 1];
    }
    public void setCampoNombreClass(int columnaIdx, String campNomClass) throws SQLException {
        this.campNomClass[columnaIdx - 1] = campNomClass;
    }
    public Class getCampoClass(int columnaIdx) {
        return this.campClass[columnaIdx - 1];
    }
    public void setCampoClass(int columnaIdx, Class campClass) {
        this.campClass[columnaIdx - 1] = campClass;
    }
    protected void llenarLeerMethod(int columnaIdx, String nomCamp) throws java.sql.SQLException {
        try {
            Method lMethod = (new PropertyDescriptor(nomCamp, this.peticio)).getReadMethod();
            this.setLeerMethod(columnaIdx, lMethod);
        } catch (IntrospectionException ie) {
            if (throwExcepcioCampInexistent) {
                ie.printStackTrace();
                throw new RuntimeException(ie);
            }
        }
    }
    protected void llenarGrabarMethod(int columnaIdx, String nomCamp) throws java.sql.SQLException {
        try {
            Method gMethod = (new PropertyDescriptor(nomCamp, this.peticio)).getWriteMethod();
            this.setGrabarMethod(columnaIdx, gMethod);
            Class[] tiposParms = gMethod.getParameterTypes();
            Class paramClass = tiposParms[0];
            this.setCampoClass(columnaIdx, paramClass);
            this.setCampoNombreClass(columnaIdx, paramClass.getName());
        } catch (IntrospectionException ie) {
            if (throwExcepcioCampInexistent) {
                ie.printStackTrace();
                throw new RuntimeException(ie);
            }
        }
    }
    public void llenar(Map mapping, Class peticio) throws java.sql.SQLException {
        if (mapping == null || mapping.isEmpty()) {
            throw new SQLException("Mapejador: invalido/ausente mapping");
        }
        this.peticio = peticio;
        int contColumna = mapping.size();
        this.setContadorColumna(contColumna);
        this.nomCataleg = new String[contColumna];
        this.nomEsquema = new String[contColumna];
        this.nomTaula = new String[contColumna];
        this.nomColumna = new String[contColumna];
        this.etiquetaColumna = new String[contColumna];
        this.solsLectura = new boolean[contColumna];
        this.grabable = new boolean[contColumna];
        this.tipusColumna = new int[contColumna];
        this.columnaNomComplert = new String[contColumna];
        this.nomCamp = new String[contColumna];
        this.llegirMethod = new Method[contColumna];
        this.gravarMethod = new Method[contColumna];
        this.campClass = new Class[contColumna];
        this.campNomClass = new String[contColumna];
        Iterator iter = mapping.keySet().iterator();
        int columnaIdx = 1;
        while (iter.hasNext()) {
            String catalogo = null;
            String esquema = null;
            String tabla = null;
            String tablaId = null;
            String column = null;
            String completoNombreCol = (String) iter.next();
            StringTokenizer st = new StringTokenizer(completoNombreCol, ".", false);
            int tokens = st.countTokens();
            if (tokens == 2) { // solo tabla y nombre de columna, sin esquema ni catalogo
                int idx1 = completoNombreCol.indexOf(".");
                tablaId = completoNombreCol.substring(0, idx1).trim();
                tabla = tablaId;
            } else if (tokens == 3) { // no se proporciona el catálogo
                int idx1 = completoNombreCol.indexOf(".");
                int idx2 = completoNombreCol.lastIndexOf(".");
                tablaId = completoNombreCol.substring(0, idx2).trim();
                tabla = completoNombreCol.substring(idx1 + 1, idx2).trim();
                esquema = completoNombreCol.substring(0, idx1).trim();
            } else if (tokens == 4) { // catalogo, esquema, tabla y columna
                tablaId = completoNombreCol.substring(0, completoNombreCol.lastIndexOf(".")).trim();
                int i = 0;
                while (st.hasMoreTokens() && i < 3) {
                    String token = st.nextToken().trim();
                    if (i == 0) {
                        catalogo = token;
                    } else if (i == 1) {
                        esquema = token;
                    } else if (i == 2) {
                        tabla = token;
                    }
                    i++;
                }
            } else {
                throw new IllegalArgumentException("Mapeo BBDD no valido");
            }
            this.setNomCataleg(columnaIdx, catalogo);
            this.setNomEsquema(columnaIdx, esquema);
            this.setNomTaula(columnaIdx, tabla);
            this.setNomColumna(columnaIdx, completoNombreCol.substring(completoNombreCol.lastIndexOf(".") + 1));
            this.setColumnaNomComplert(columnaIdx, completoNombreCol);
            String nomCamp = (String) mapping.get(completoNombreCol);
            this.setNomCamp(columnaIdx, nomCamp);
            String[] tablasDistintas = new String[3];
            tablasDistintas[0] = catalogo;
            tablasDistintas[1] = esquema;
            tablasDistintas[2] = tabla;
            this.taulesMap.put(tablaId, tablasDistintas);
            this.setSolsLectura(columnaIdx, false);
//this.setGrabable(columnaIdx, true); //ver setSoloLectura() method
            this.llenarLeerMethod(columnaIdx, nomCamp);
            this.llenarGrabarMethod(columnaIdx, nomCamp);
            this.setEtiquetaColumna(columnaIdx, toEtiqueta(getNomColumna(columnaIdx)));
            columnaIdx++;
        }
    }
    public int getIndiceColumnaPorNombreCampo(String nomCampBuscado) {
        if (nomCampBuscado == null) {
            return -1;
        }
        for (int i = 0; i < this.nomCamp.length; i++) {
            if (nomCamp[i] == null) {
                return -1;
            }
            if (nomCampBuscado.equalsIgnoreCase(nomCamp[i])) {
                return i + 1;
            }
        }
        return -1;
    }
    public String toEtiqueta(String nomColumna) {
        String etiqueta = ((String) nomColumna).toLowerCase();
        StringBuffer sb = new StringBuffer();
        boolean toUpper = false;
        for (int i = 0; i < etiqueta.length(); i++) {
            char c = etiqueta.charAt(i);
            if (c != '_') {
                if (i == 0) {
                    toUpper = true;
                }
                if (toUpper) {
                    c = Character.toUpperCase(c);
                } else {
                }
                sb.append(c);
                toUpper = false;
            } else {
                if (i > 0) {
                    sb.append(' ');
                }
                toUpper = true;
            }
        }
        return sb.toString();
    }
    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer("lwpf ============ org.lwpf.MapejadorObjectes: ");
        sb.append("\ncomptadorColumna: " + comptadorColumna);
        sb.append("\nnomCataleg: " + Arrays.asList(nomCataleg));
        sb.append("\nnomEsquema: " + Arrays.asList(nomEsquema));
        sb.append("\nnomTaula: " + Arrays.asList(nomTaula));
//sb.append("\ncolumnaNomClass: " + Arrays.asList(columnaNomClass));
        sb.append("\netiquetaColumna: " + Arrays.asList(etiquetaColumna));
        sb.append("\nnomColumna: " + Arrays.asList(nomColumna));
        sb.append("\ncolumnaNomComplert: " + Arrays.asList(columnaNomComplert));
        sb.append("\nnomCamp: " + Arrays.asList(nomCamp));
        sb.append("\nllegirMethod: " + Arrays.asList(llegirMethod));
        sb.append("\ngravarMethod: " + Arrays.asList(gravarMethod));
//sb.append("\ngrabable: " + Arrays.asList(grabable));
        sb.append("\ncampNomClass: " + Arrays.asList(campNomClass));
        sb.append("\npeticio: " + peticio);
        return sb.toString();
    }
    public boolean isThrowExcepcionCampoAusente() {
        return throwExcepcioCampInexistent;
    }
    public void setThrowExcepcionCampoAusente(boolean throwExcepcioCampInexistent) {
        this.throwExcepcioCampInexistent = throwExcepcioCampInexistent;
    }
}
